home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2007 September / PCWSEP07.iso / Software / Linux / Linux Mint 3.0 Light / LinuxMint-3.0-Light.iso / casper / filesystem.squashfs / usr / share / gettext / intl / relocatable.c < prev    next >
Encoding:
C/C++ Source or Header  |  2007-03-05  |  13.8 KB  |  469 lines
  1. /* Provide relocatable packages.
  2.    Copyright (C) 2003-2006 Free Software Foundation, Inc.
  3.    Written by Bruno Haible <bruno@clisp.org>, 2003.
  4.  
  5.    This program is free software; you can redistribute it and/or modify it
  6.    under the terms of the GNU Library General Public License as published
  7.    by the Free Software Foundation; either version 2, or (at your option)
  8.    any later version.
  9.  
  10.    This program is distributed in the hope that it will be useful,
  11.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13.    Library General Public License for more details.
  14.  
  15.    You should have received a copy of the GNU Library General Public
  16.    License along with this program; if not, write to the Free Software
  17.    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  18.    USA.  */
  19.  
  20.  
  21. /* Tell glibc's <stdio.h> to provide a prototype for getline().
  22.    This must come before <config.h> because <config.h> may include
  23.    <features.h>, and once <features.h> has been included, it's too late.  */
  24. #ifndef _GNU_SOURCE
  25. # define _GNU_SOURCE    1
  26. #endif
  27.  
  28. #include <config.h>
  29.  
  30. /* Specification.  */
  31. #include "relocatable.h"
  32.  
  33. #if ENABLE_RELOCATABLE
  34.  
  35. #include <stddef.h>
  36. #include <stdio.h>
  37. #include <stdlib.h>
  38. #include <string.h>
  39.  
  40. #ifdef NO_XMALLOC
  41. # define xmalloc malloc
  42. #else
  43. # include "xalloc.h"
  44. #endif
  45.  
  46. #if defined _WIN32 || defined __WIN32__ || defined __CYGWIN__
  47. # define WIN32_LEAN_AND_MEAN
  48. # include <windows.h>
  49. #endif
  50.  
  51. #if DEPENDS_ON_LIBCHARSET
  52. # include <libcharset.h>
  53. #endif
  54. #if DEPENDS_ON_LIBICONV && HAVE_ICONV
  55. # include <iconv.h>
  56. #endif
  57. #if DEPENDS_ON_LIBINTL && ENABLE_NLS
  58. # include <libintl.h>
  59. #endif
  60.  
  61. /* Faked cheap 'bool'.  */
  62. #undef bool
  63. #undef false
  64. #undef true
  65. #define bool int
  66. #define false 0
  67. #define true 1
  68.  
  69. /* Pathname support.
  70.    ISSLASH(C)           tests whether C is a directory separator character.
  71.    IS_PATH_WITH_DIR(P)  tests whether P contains a directory specification.
  72.  */
  73. #if defined _WIN32 || defined __WIN32__ || defined __CYGWIN__ || defined __EMX__ || defined __DJGPP__
  74.   /* Win32, Cygwin, OS/2, DOS */
  75. # define ISSLASH(C) ((C) == '/' || (C) == '\\')
  76. # define HAS_DEVICE(P) \
  77.     ((((P)[0] >= 'A' && (P)[0] <= 'Z') || ((P)[0] >= 'a' && (P)[0] <= 'z')) \
  78.      && (P)[1] == ':')
  79. # define IS_PATH_WITH_DIR(P) \
  80.     (strchr (P, '/') != NULL || strchr (P, '\\') != NULL || HAS_DEVICE (P))
  81. # define FILE_SYSTEM_PREFIX_LEN(P) (HAS_DEVICE (P) ? 2 : 0)
  82. #else
  83.   /* Unix */
  84. # define ISSLASH(C) ((C) == '/')
  85. # define IS_PATH_WITH_DIR(P) (strchr (P, '/') != NULL)
  86. # define FILE_SYSTEM_PREFIX_LEN(P) 0
  87. #endif
  88.  
  89. /* Original installation prefix.  */
  90. static char *orig_prefix;
  91. static size_t orig_prefix_len;
  92. /* Current installation prefix.  */
  93. static char *curr_prefix;
  94. static size_t curr_prefix_len;
  95. /* These prefixes do not end in a slash.  Anything that will be concatenated
  96.    to them must start with a slash.  */
  97.  
  98. /* Sets the original and the current installation prefix of this module.
  99.    Relocation simply replaces a pathname starting with the original prefix
  100.    by the corresponding pathname with the current prefix instead.  Both
  101.    prefixes should be directory names without trailing slash (i.e. use ""
  102.    instead of "/").  */
  103. static void
  104. set_this_relocation_prefix (const char *orig_prefix_arg,
  105.                 const char *curr_prefix_arg)
  106. {
  107.   if (orig_prefix_arg != NULL && curr_prefix_arg != NULL
  108.       /* Optimization: if orig_prefix and curr_prefix are equal, the
  109.      relocation is a nop.  */
  110.       && strcmp (orig_prefix_arg, curr_prefix_arg) != 0)
  111.     {
  112.       /* Duplicate the argument strings.  */
  113.       char *memory;
  114.  
  115.       orig_prefix_len = strlen (orig_prefix_arg);
  116.       curr_prefix_len = strlen (curr_prefix_arg);
  117.       memory = (char *) xmalloc (orig_prefix_len + 1 + curr_prefix_len + 1);
  118. #ifdef NO_XMALLOC
  119.       if (memory != NULL)
  120. #endif
  121.     {
  122.       memcpy (memory, orig_prefix_arg, orig_prefix_len + 1);
  123.       orig_prefix = memory;
  124.       memory += orig_prefix_len + 1;
  125.       memcpy (memory, curr_prefix_arg, curr_prefix_len + 1);
  126.       curr_prefix = memory;
  127.       return;
  128.     }
  129.     }
  130.   orig_prefix = NULL;
  131.   curr_prefix = NULL;
  132.   /* Don't worry about wasted memory here - this function is usually only
  133.      called once.  */
  134. }
  135.  
  136. /* Sets the original and the current installation prefix of the package.
  137.    Relocation simply replaces a pathname starting with the original prefix
  138.    by the corresponding pathname with the current prefix instead.  Both
  139.    prefixes should be directory names without trailing slash (i.e. use ""
  140.    instead of "/").  */
  141. void
  142. set_relocation_prefix (const char *orig_prefix_arg, const char *curr_prefix_arg)
  143. {
  144.   set_this_relocation_prefix (orig_prefix_arg, curr_prefix_arg);
  145.  
  146.   /* Now notify all dependent libraries.  */
  147. #if DEPENDS_ON_LIBCHARSET
  148.   libcharset_set_relocation_prefix (orig_prefix_arg, curr_prefix_arg);
  149. #endif
  150. #if DEPENDS_ON_LIBICONV && HAVE_ICONV && _LIBICONV_VERSION >= 0x0109
  151.   libiconv_set_relocation_prefix (orig_prefix_arg, curr_prefix_arg);
  152. #endif
  153. #if DEPENDS_ON_LIBINTL && ENABLE_NLS && defined libintl_set_relocation_prefix
  154.   libintl_set_relocation_prefix (orig_prefix_arg, curr_prefix_arg);
  155. #endif
  156. }
  157.  
  158. #if !defined IN_LIBRARY || (defined PIC && defined INSTALLDIR)
  159.  
  160. /* Convenience function:
  161.    Computes the current installation prefix, based on the original
  162.    installation prefix, the original installation directory of a particular
  163.    file, and the current pathname of this file.  Returns NULL upon failure.  */
  164. #ifdef IN_LIBRARY
  165. #define compute_curr_prefix local_compute_curr_prefix
  166. static
  167. #endif
  168. const char *
  169. compute_curr_prefix (const char *orig_installprefix,
  170.              const char *orig_installdir,
  171.              const char *curr_pathname)
  172. {
  173.   const char *curr_installdir;
  174.   const char *rel_installdir;
  175.  
  176.   if (curr_pathname == NULL)
  177.     return NULL;
  178.  
  179.   /* Determine the relative installation directory, relative to the prefix.
  180.      This is simply the difference between orig_installprefix and
  181.      orig_installdir.  */
  182.   if (strncmp (orig_installprefix, orig_installdir, strlen (orig_installprefix))
  183.       != 0)
  184.     /* Shouldn't happen - nothing should be installed outside $(prefix).  */
  185.     return NULL;
  186.   rel_installdir = orig_installdir + strlen (orig_installprefix);
  187.  
  188.   /* Determine the current installation directory.  */
  189.   {
  190.     const char *p_base = curr_pathname + FILE_SYSTEM_PREFIX_LEN (curr_pathname);
  191.     const char *p = curr_pathname + strlen (curr_pathname);
  192.     char *q;
  193.  
  194.     while (p > p_base)
  195.       {
  196.     p--;
  197.     if (ISSLASH (*p))
  198.       break;
  199.       }
  200.  
  201.     q = (char *) xmalloc (p - curr_pathname + 1);
  202. #ifdef NO_XMALLOC
  203.     if (q == NULL)
  204.       return NULL;
  205. #endif
  206.     memcpy (q, curr_pathname, p - curr_pathname);
  207.     q[p - curr_pathname] = '\0';
  208.     curr_installdir = q;
  209.   }
  210.  
  211.   /* Compute the current installation prefix by removing the trailing
  212.      rel_installdir from it.  */
  213.   {
  214.     const char *rp = rel_installdir + strlen (rel_installdir);
  215.     const char *cp = curr_installdir + strlen (curr_installdir);
  216.     const char *cp_base =
  217.       curr_installdir + FILE_SYSTEM_PREFIX_LEN (curr_installdir);
  218.  
  219.     while (rp > rel_installdir && cp > cp_base)
  220.       {
  221.     bool same = false;
  222.     const char *rpi = rp;
  223.     const char *cpi = cp;
  224.  
  225.     while (rpi > rel_installdir && cpi > cp_base)
  226.       {
  227.         rpi--;
  228.         cpi--;
  229.         if (ISSLASH (*rpi) || ISSLASH (*cpi))
  230.           {
  231.         if (ISSLASH (*rpi) && ISSLASH (*cpi))
  232.           same = true;
  233.         break;
  234.           }
  235.         /* Do case-insensitive comparison if the filesystem is always or
  236.            often case-insensitive.  It's better to accept the comparison
  237.            if the difference is only in case, rather than to fail.  */
  238. #if defined _WIN32 || defined __WIN32__ || defined __CYGWIN__ || defined __EMX__ || defined __DJGPP__
  239.         /* Win32, Cygwin, OS/2, DOS - case insignificant filesystem */
  240.         if ((*rpi >= 'a' && *rpi <= 'z' ? *rpi - 'a' + 'A' : *rpi)
  241.         != (*cpi >= 'a' && *cpi <= 'z' ? *cpi - 'a' + 'A' : *cpi))
  242.           break;
  243. #else
  244.         if (*rpi != *cpi)
  245.           break;
  246. #endif
  247.       }
  248.     if (!same)
  249.       break;
  250.     /* The last pathname component was the same.  opi and cpi now point
  251.        to the slash before it.  */
  252.     rp = rpi;
  253.     cp = cpi;
  254.       }
  255.  
  256.     if (rp > rel_installdir)
  257.       /* Unexpected: The curr_installdir does not end with rel_installdir.  */
  258.       return NULL;
  259.  
  260.     {
  261.       size_t curr_prefix_len = cp - curr_installdir;
  262.       char *curr_prefix;
  263.  
  264.       curr_prefix = (char *) xmalloc (curr_prefix_len + 1);
  265. #ifdef NO_XMALLOC
  266.       if (curr_prefix == NULL)
  267.     return NULL;
  268. #endif
  269.       memcpy (curr_prefix, curr_installdir, curr_prefix_len);
  270.       curr_prefix[curr_prefix_len] = '\0';
  271.  
  272.       return curr_prefix;
  273.     }
  274.   }
  275. }
  276.  
  277. #endif /* !IN_LIBRARY || PIC */
  278.  
  279. #if defined PIC && defined INSTALLDIR
  280.  
  281. /* Full pathname of shared library, or NULL.  */
  282. static char *shared_library_fullname;
  283.  
  284. #if defined _WIN32 || defined __WIN32__ || defined __CYGWIN__
  285.  
  286. /* Determine the full pathname of the shared library when it is loaded.  */
  287.  
  288. BOOL WINAPI
  289. DllMain (HINSTANCE module_handle, DWORD event, LPVOID reserved)
  290. {
  291.   (void) reserved;
  292.  
  293.   if (event == DLL_PROCESS_ATTACH)
  294.     {
  295.       /* The DLL is being loaded into an application's address range.  */
  296.       static char location[MAX_PATH];
  297.  
  298.       if (!GetModuleFileName (module_handle, location, sizeof (location)))
  299.     /* Shouldn't happen.  */
  300.     return FALSE;
  301.  
  302.       if (!IS_PATH_WITH_DIR (location))
  303.     /* Shouldn't happen.  */
  304.     return FALSE;
  305.  
  306.       {
  307. #if defined __CYGWIN__
  308.     /* On Cygwin, we need to convert paths coming from Win32 system calls
  309.        to the Unix-like slashified notation.  */
  310.     static char location_as_posix_path[2 * MAX_PATH];
  311.     /* There's no error return defined for cygwin_conv_to_posix_path.
  312.        See cygwin-api/func-cygwin-conv-to-posix-path.html.
  313.        Does it overflow the buffer of expected size MAX_PATH or does it
  314.        truncate the path?  I don't know.  Let's catch both.  */
  315.     cygwin_conv_to_posix_path (location, location_as_posix_path);
  316.     location_as_posix_path[MAX_PATH - 1] = '\0';
  317.     if (strlen (location_as_posix_path) >= MAX_PATH - 1)
  318.       /* A sign of buffer overflow or path truncation.  */
  319.       return FALSE;
  320.     shared_library_fullname = strdup (location_as_posix_path);
  321. #else
  322.     shared_library_fullname = strdup (location);
  323. #endif
  324.       }
  325.     }
  326.  
  327.   return TRUE;
  328. }
  329.  
  330. #else /* Unix except Cygwin */
  331.  
  332. static void
  333. find_shared_library_fullname ()
  334. {
  335. #if defined __linux__ && __GLIBC__ >= 2
  336.   /* Linux has /proc/self/maps. glibc 2 has the getline() function.  */
  337.   FILE *fp;
  338.  
  339.   /* Open the current process' maps file.  It describes one VMA per line.  */
  340.   fp = fopen ("/proc/self/maps", "r");
  341.   if (fp)
  342.     {
  343.       unsigned long address = (unsigned long) &find_shared_library_fullname;
  344.       for (;;)
  345.     {
  346.       unsigned long start, end;
  347.       int c;
  348.  
  349.       if (fscanf (fp, "%lx-%lx", &start, &end) != 2)
  350.         break;
  351.       if (address >= start && address <= end - 1)
  352.         {
  353.           /* Found it.  Now see if this line contains a filename.  */
  354.           while (c = getc (fp), c != EOF && c != '\n' && c != '/')
  355.         continue;
  356.           if (c == '/')
  357.         {
  358.           size_t size;
  359.           int len;
  360.  
  361.           ungetc (c, fp);
  362.           shared_library_fullname = NULL; size = 0;
  363.           len = getline (&shared_library_fullname, &size, fp);
  364.           if (len >= 0)
  365.             {
  366.               /* Success: filled shared_library_fullname.  */
  367.               if (len > 0 && shared_library_fullname[len - 1] == '\n')
  368.             shared_library_fullname[len - 1] = '\0';
  369.             }
  370.         }
  371.           break;
  372.         }
  373.       while (c = getc (fp), c != EOF && c != '\n')
  374.         continue;
  375.     }
  376.       fclose (fp);
  377.     }
  378. #endif
  379. }
  380.  
  381. #endif /* (WIN32 or Cygwin) / (Unix except Cygwin) */
  382.  
  383. /* Return the full pathname of the current shared library.
  384.    Return NULL if unknown.
  385.    Guaranteed to work only on Linux, Cygwin and Woe32.  */
  386. static char *
  387. get_shared_library_fullname ()
  388. {
  389. #if !(defined _WIN32 || defined __WIN32__ || defined __CYGWIN__)
  390.   static bool tried_find_shared_library_fullname;
  391.   if (!tried_find_shared_library_fullname)
  392.     {
  393.       find_shared_library_fullname ();
  394.       tried_find_shared_library_fullname = true;
  395.     }
  396. #endif
  397.   return shared_library_fullname;
  398. }
  399.  
  400. #endif /* PIC */
  401.  
  402. /* Returns the pathname, relocated according to the current installation
  403.    directory.  */
  404. const char *
  405. relocate (const char *pathname)
  406. {
  407. #if defined PIC && defined INSTALLDIR
  408.   static int initialized;
  409.  
  410.   /* Initialization code for a shared library.  */
  411.   if (!initialized)
  412.     {
  413.       /* At this point, orig_prefix and curr_prefix likely have already been
  414.      set through the main program's set_program_name_and_installdir
  415.      function.  This is sufficient in the case that the library has
  416.      initially been installed in the same orig_prefix.  But we can do
  417.      better, to also cover the cases that 1. it has been installed
  418.      in a different prefix before being moved to orig_prefix and (later)
  419.      to curr_prefix, 2. unlike the program, it has not moved away from
  420.      orig_prefix.  */
  421.       const char *orig_installprefix = INSTALLPREFIX;
  422.       const char *orig_installdir = INSTALLDIR;
  423.       const char *curr_prefix_better;
  424.  
  425.       curr_prefix_better =
  426.     compute_curr_prefix (orig_installprefix, orig_installdir,
  427.                  get_shared_library_fullname ());
  428.       if (curr_prefix_better == NULL)
  429.     curr_prefix_better = curr_prefix;
  430.  
  431.       set_relocation_prefix (orig_installprefix, curr_prefix_better);
  432.  
  433.       initialized = 1;
  434.     }
  435. #endif
  436.  
  437.   /* Note: It is not necessary to perform case insensitive comparison here,
  438.      even for DOS-like filesystems, because the pathname argument was
  439.      typically created from the same Makefile variable as orig_prefix came
  440.      from.  */
  441.   if (orig_prefix != NULL && curr_prefix != NULL
  442.       && strncmp (pathname, orig_prefix, orig_prefix_len) == 0)
  443.     {
  444.       if (pathname[orig_prefix_len] == '\0')
  445.     /* pathname equals orig_prefix.  */
  446.     return curr_prefix;
  447.       if (ISSLASH (pathname[orig_prefix_len]))
  448.     {
  449.       /* pathname starts with orig_prefix.  */
  450.       const char *pathname_tail = &pathname[orig_prefix_len];
  451.       char *result =
  452.         (char *) xmalloc (curr_prefix_len + strlen (pathname_tail) + 1);
  453.  
  454. #ifdef NO_XMALLOC
  455.       if (result != NULL)
  456. #endif
  457.         {
  458.           memcpy (result, curr_prefix, curr_prefix_len);
  459.           strcpy (result + curr_prefix_len, pathname_tail);
  460.           return result;
  461.         }
  462.     }
  463.     }
  464.   /* Nothing to relocate.  */
  465.   return pathname;
  466. }
  467.  
  468. #endif
  469.